#include "Unordered_set.h"
#include "Unordered_map.h"
#include <thread>

template<class K, class T>
struct KOfT
{
	const K& operator()(const T& val)
	{
		return val;
	}
};

void TestHashTable()
{
	lw::HashTable<int, int> hash;
	hash.Insert({ 1,1 });
	hash.Insert({ 2,2 });
	hash.Insert({ 3,3 });
	hash.Insert({ 4,4 });
	hash.Insert({ 5,5 });

	int pos1 = hash.Find(1);
	int pos2 = hash.Find(2);
	
	hash.Erase(2);
	hash.Erase(3);
}

void TestHashBucket()
{
	/*bucket::HashBucket<std::string, std::pair<std::string, int>, KOfT<std::string, std::pair<std::string, int>>> hash;
	hash.Insert({ "aaa", 1 });
	hash.Insert({ "bbb", 2 });
	hash.Insert({ "ccc", 3 });*/
	/*bucket::HashBucket<int, int, KOfT<int, int>> hash;
	hash.Insert(1);
	hash.Insert(5);
	hash.Insert(2);
	hash.Insert(3);
	hash.Insert(4);

	auto it1 = hash.Find(3);
	auto it2 = hash.Find(1);
	hash.Erase(2);
	hash.Erase(4);
	auto it3 = hash.Find(2);*/

	/*auto iter = hash.begin();
	++iter;
	++iter;
	++iter;
	++iter;
	++iter;
	++iter;
	++iter;*/
}

void TestSet()
{
	/*myset::set<int> s;
	s.Insert(1);
	s.Insert(2);
	s.Insert(5);
	s.Insert(4);
	s.Insert(3);

	auto it1 = s.Find(4);
	auto it2 = s.Find(1);

	s.Erase(1);
	s.Erase(2);
	s.Erase(3);
	s.Erase(4);
	s.Erase(5);*/

	myset::unordered_set<std::string> s;
	s.Insert("aaa");
	s.Insert("bbb");
	s.Insert("ccc");
	s.Insert("ddd");
	s.Insert("eee");

	for (auto e : s)
	{
		printf("%s\n", e.c_str());
	}

	auto it1 = s.Find("aaa");
	auto it2 = s.Find("ddd");

	s.Erase("aaa");
	s.Erase("bbb");
	s.Erase("ccc");
	s.Erase("ddd");
	s.Erase("eee");
}

void TestMap()
{
	mymap::unordered_map<std::string, int> m1;
	std::vector<std::string> v = { "aaa", "aaa", "bbb", "ccc", "bbb", "aaa" };
	for (auto e : v)
	{
		m1[e]++;
	}

	/*for (auto e : m1)
	{
		printf("%s: %d\n", e.first.c_str(), e.second);
	}*/
	mymap::unordered_map<std::string, int>::iterator it = m1.begin();
	while (it != m1.end())
	{
		printf("%s: %d\n", it->first.c_str(), it->second);
		++it;
	}
	
}

int main()
{
	TestMap();
	return 0;
}